package first1


import scala.collection.mutable.ArrayBuffer

/**
  * description
  *
  * @author Llx
  * @version v1.0.0
  * @since 2018/10/8
  */

object JiBenShuJuLeiXingTest {

  def f1(x:Int,y:Int):Int ={
    if(x>y)
      2
    else
      1
  }

  /**
    * x:call by value 直接进行计算完后，进入方法
    * y:call by name 不进行计算，待用到后进行计算
    * @param x
    * @param y
    * @return
    */
  def f2(x:Int,y: =>Int)={
    println("11111111111111111")
    x+y
  }

  /**
    * for 循环 () 不可以计算，只能嵌套if
    *         {}里面可以进行计算
    * @return
    */
  def f3()={
    val list = List("1","2","3","4")
    for (e<-list
          if e.equals("1"))
      println(e)


	/**
    *  采用until 循环  for(i<- 0 until x.length)   复初始值 i<- 0
    *         
    * @return
    */ 
  def sumD(x:Int*):Int = {
    var ret = 0
    for(i<- 0 until x.length){
      ret += x(i)
    }
    ret

  }
    /**
      * while 类型for的 ()
      * list 通过小括号，获取 小标的值
      */
    var i = 0
    while (i < list.size){
      println(list(i))
      i += 1
    }


    /**
      * do while 更while一样 不过是先do
      */
    i = 0
    do{
      println(list(i))
      i += 1
    }while(i< list.size)

    /**
      * for
      */
    for {s <- list
         k = s + s
    } yield (k)

  }


  def f4 (x:Int=0,y:String="moren"): Unit ={
    println("nihao" + x + y)

  }

  /**
    * 异常处理
    */
  def f5 (): Unit ={
    try {
      val string = scala.io.Source.fromFile("").mkString
    }catch {
      case e:java.io.FileNotFoundException=>{
        println("文件不存在")
      }
      case _:Exception =>{
        println("未知异常")
      }
    }finally {
      println("最后处理")
    }
  }

  /**
    * 数组 定长数组  变长数组
    *
    */
  def f6(): Unit ={
    val newLength = new Array[Int](10)
    val initSize = Array("sd","sd")

    val buffer = new ArrayBuffer[Int]()
    buffer += 1
    buffer += 2
    buffer +=(12,12)
    val array = buffer.toArray

    //函数内必须返回一个list，然后对所有list做flat，最后返回一个list
    val flat = array.flatMap(x => {
      List(x, 0)
    })
   println(flat)

    //函数返回类型没有限制，最后都所有返回结果，封装到一个list中
    val map = array.map(x => {
      List(x, 0)
    })
    println(map)
  }

  /**
    * 多维数组
    *
    */
  def f7(): Unit ={
    //通过new 方式
    val i = new Array[Array[Int]](10)
    i(0)=Array(1,2,1)
    i(1)=Array(1,2)
    //通过dim方式
    val twoArray = Array.ofDim[Int](2,3)
    twoArray(0)=Array(1,1,2,1)
    println(i)
    println(twoArray)
  }


  /**
    * 映射 map ：不变map 可变map
    */
  def f8(): Unit ={

    val map = scala.collection.immutable.Map("zhangsan"->12)
    val map2 =scala.collection.mutable.Map(("zhangsan",12),("wangsi",12))

    //赋值 map不可变，不能赋值
    map2("wangsi") = 145
    //获取方式
    map.getOrElse("zhangsan",-1)
    map("zhangsan")
    //迭代
    for(x<- map)
      println(x)
  }

  /**
    * 元组 tuple3 :表示有三个元素
    *       表示形式：(1,2,3)
    *
    */
  def f9: Unit ={
    //创建方式
    val t1 = (1,2,3)
    val t2 = new Tuple3(1,2,3)
    //获取成员值： _N
    println(t1._1)

    //遍历 productIterator先生产迭代器
    t2.productIterator.foreach(x=>{
      println(x)
    })
  }


  /**
    * 列表
    * list 可变  不可变
    * 序列
    * vector
    *
    *  set 交 并 差  set(1,2,3)
    *
    */
  def f10(): Unit ={

    val list = scala.collection.mutable.MutableList(1,2,3)
    list+=2

    list.foreach(x=>{
      println(x)
    })

  }


  /**
    * 样本类：可以用于模式匹配
    * @param a
    */
  case class AAA(a:Int){
  }

  /**
    * 模式匹配 match 守卫 类型匹配(数组 list)
    */
  def f11(): Unit ={

    var sign = 0
    var ch1 = '-'

    ch1 match {
      case '+' =>sign =1
      case '-' => sign =2

      case _ if Character.isDigit(ch1)  => sign=0   //if Scala的守卫
      case _ => sign=0
    }
    println(sign)

    var array = Array(1,2,3)

    var list = List(1,2,3)

    array match {
      case Array(x,y)=>println("这是两个元素的数组")
      case Array(x,_*) => println("这是数组")
    }

    list match {
      case List(x,y)=>println("这是两个元素的list")
      case List(x,_*) => println("这是list")
    }
  }


  def f12(): Boolean ={
    val array = new Array[Array[Int]](3)
    array(0)=Array(1,2,3)
    array(1)=Array(4,5,6)
    array(2)=Array(7,8,9)

    val taget = 91

    var row = array.size-1
    var celLength = array(0).length-1

    while (row>=0 && row<array.size){
      if(taget < array(row)(0)){
        row -=1
      }else if(taget >array(row)(celLength)){
        row +=1
      }else {
        return true
      }
    }
    return false
  }


  def main(args: Array[String]): Unit = {
//
//    f4(1,"12")
//    f4(y="张三")
//
//    /**
//      * 调用 k的时候，才会去 调用f2方法
//      */
//    lazy val k: Int = f2(1,2) + 1
//    println(k)
    println(f12())
  }

}

